﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<set>
#include<map>
using namespace std;


//template < class T,                        // set::key_type/value_type
//    class Compare = less<T>,        // set::key_compare/value_compare
//    class Alloc = allocator<T>      // set::allocator_type
//> class set;

//explicit set(const key_compare& comp = key_compare(),
//    const allocator_type& alloc = allocator_type());

//template <class InputIterator>
//set(InputIterator first, InputIterator last,
//    const key_compare& comp = key_compare(),
//    const allocator_type& alloc = allocator_type());

//set(const set& x);
//set(const set& x, const allocator_type& alloc);

//set(initializer_list<value_type> il,
//    const key_compare& comp = key_compare(),
//    const allocator_type& alloc = allocator_type());


//// 正向迭代器
//iterator begin();
//iterator end();
//// 反向迭代器
//reverse_iterator rbegin();
//reverse_iterator rend();


//// 单个数据插⼊，如果已经存在则插⼊失败
//pair<iterator, bool> insert(const value_type& val);
//// 列表插⼊，已经在容器中存在的值不会插⼊
//void insert(initializer_list<value_type> il);
//// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
//template <class InputIterator>
//void insert(InputIterator first, InputIterator last);


//int main()
//{
//	// 去重+升序排序
//	set<int> s;
//
//	// 去重+降序排序（给⼀个⼤于的仿函数）
//	//set<int, greater<int>> s;
//	s.insert(5);
//	s.insert(2);
//	s.insert(7);
//	s.insert(5);
//
//	set<int>::iterator it = s.begin();
//	while (it != s.end())
//	{
//		// error C3892: “it”: 不能给常量赋值
//		// *it = 1;
//
//		cout << *it << " ";
//		++it;
//	}
//	cout << endl;
//	return 0;
//}

//int main()
//{
//	set<int> s;
//	s.insert({ 2,8,3,9 });
//	for (auto e : s)
//	{
//		cout << e << " ";
//	} 
//	cout << endl;
//	return 0;
//}


//int main()
//{
//	set<string> strset = { "sort", "insert", "add" };
//	// 遍历string⽐较ascll码⼤⼩顺序遍历的
//	for (auto& e : strset)
//	{
//		cout << e << " ";
//	} 
//	return 0;
//}

//
//const_iterator find(const value_type& val) const;
//iterator       find(const value_type& val);


//iterator  erase(const_iterator position);
//
//size_type erase(const value_type& val);
//
//iterator  erase(const_iterator first, const_iterator last);

//size_type count(const value_type& val) const;

//int main()
//{
//	set<int> s = { 4,2,7,2,8,5,9 };
//	for (auto e : s)
//	{
//		cout << e << " ";
//	} 
//	cout << endl;
//
//	// 删除最⼩值
//	s.erase(s.begin());
//	for (auto e : s)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	// 直接删除x
//	int x;
//	cin >> x;
//	int num = s.erase(x);
//	if (num == 0)
//	{
//		cout << x << "不存在！" << endl;
//	} 
//	for (auto e : s)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	// 直接查找在利⽤迭代器删除x
//	cin >> x;
//	auto pos = s.find(x);
//	if (pos != s.end())
//	{
//		s.erase(pos);
//	}
//	else
//	{
//		cout << x << "不存在！" << endl;
//	}
//	for (auto e : s)
//	{
//		cout << e << " ";
//	} 
//	cout << endl;
//
//	return 0;
//}
		

//int main()
//{
//	set<int> s = { 4,2,7,2,8,5,9 };
//	
//	// 利⽤count间接实现快速查找
//	int x;
//	cin >> x;
//	if (s.count(x))
//	{
//		cout << x << "在！" << endl;
//	} 
//	else
//	{
//		cout << x << "不存在！" << endl;
//	} 
//	return 0;
//}

//// 返回⼤于等val位置的迭代器
//iterator lower_bound(const value_type& val) const;
//// 返回⼤于val位置的迭代器
//iterator upper_bound(const value_type& val) const;



//int main()
//{
//	std::set<int> myset;
//	for (int i = 1; i < 10; i++)
//		myset.insert(i * 10); // 10 20 30 40 50 60 70 80 90
//	for (auto e : myset)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	//// 实现查找到的[itlow,itup)包含[30, 60]区间
//	//// 返回 >= 30
//	//auto itlow = myset.lower_bound(30);
//	//// 返回 > 60
//	//auto itup = myset.upper_bound(60);
//
//	// 实现查找到的[itlow,itup)包含[25, 55]区间
//	// 返回 >= 25
//	auto itlow = myset.lower_bound(25);
//	// 返回 > 55（这里即返回60)
//	auto itup = myset.upper_bound(55);
//
//	// 删除这段区间的值
//	myset.erase(itlow, itup);
//	for (auto e : myset)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	return 0;
//}


//int main()
//{
//	// 相⽐set不同的是，multiset是排序，但是不去重
//	multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
//	auto it = s.begin();
//	while (it != s.end())
//	{
//		cout << *it << " ";
//		++it;
//	}
//	cout << endl;
//	return 0;
//}


//int main()
//{
//	multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
//	int x;
//	cin >> x;
//	auto pos = s.find(x);
//	while (pos != s.end() && *pos == x)
//	{
//		cout << *pos << " ";
//		++pos;
//	} 
//	cout << endl;
//	return 0;
//}

//int main()
//{
//	multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
//	for (auto e : s)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	int x;
//	cin >> x;
//	s.erase(x);
//	for (auto e : s)
//	{
//		cout << e << " ";
//	} 
//	cout << endl;
//	return 0;
//}


//int main()
//{
//	multiset<int> s = { 4,2,7,2,4,8,4,5,4,9 };
//	for (auto e : s)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	int x;
//	cin >> x;
//	cout << s.count(x) << endl;
//	return 0;
//}

//template < class Key,                                     // map::key_type
//    class T,                                       // map::mapped_type
//    class Compare = less<Key>,                     // map::key_compare
//    class Alloc = allocator<pair<const Key, T> >    // map::allocator_type
//> class map;
//
//template <class T1, class T2> struct pair;


//template <class T1, class T2>
//struct pair
//{
//	typedef T1 first_type;
//	typedef T2 second_type;
//	T1 first;
//	T2 second;
//	pair() : first(T1()), second(T2())
//	{}
//	pair(const T1& a, const T2& b) : first(a), second(b)
//	{}
//	template<class U, class V>
//	pair(const pair<U, V>& pr) : first(pr.first), second(pr.second)
//	{}
//};


//int main()
//{
//	map<string, string> dict;
//
//	//法一：插入有名pair对象
//	pair<string, string> kv1("left", "左边");
//	dict.insert(kv1);
//		
//	//法二：插入匿名pair对象
//	dict.insert(pair<string, string>("right", "右边"));
//
//	//法三：调用 make_pair 函数
//	dict.insert(make_pair("insert", "插入"));
//	return 0;
//
//	//法四：C++11后支持多参数的隐式类型转换
//	dict.insert({ "string", "字符串" });
//
//	return 0;
//}

//template <class T1, class T2>
//inline pair<T1, T2> make_pair(T1 x, T2 y)
//{
//	return (pair<T1, T2>(x, y));
//}

//// empty (1) ⽆参默认构造
//explicit map(const key_compare& comp = key_compare(),
//	const allocator_type& alloc = allocator_type());
//
//// range (2) 迭代器区间构造
//template <class InputIterator>
//map(InputIterator first, InputIterator last,
//	const key_compare& comp = key_compare(),
//	const allocator_type & = allocator_type());
//
//// copy (3) 拷⻉构造
//map(const map& x);
//
//// initializer list (5) initializer 列表构造
//map(initializer_list<value_type> il,
//	const key_compare& comp = key_compare(),
//	const allocator_type& alloc = allocator_type());
//
//// 迭代器是⼀个双向迭代器
//iterator->a bidirectional iterator to const value_type
//
//// 正向迭代器
//iterator begin();
//iterator end();
//// 反向迭代器
//reverse_iterator rbegin();
//reverse_iterator rend();

//
//int main()
//{
//	map<string, string> dict;
//	//法一：插入有名pair对象
//	pair<string, string> kv1("left", "左边");
//	dict.insert(kv1);
//	//法二：插入匿名pair对象
//	dict.insert(pair<string, string>("right", "右边"));
//	//法三：调用 make_pair 函数
//	dict.insert(make_pair("insert", "插入"));
//
//	//法四：C++11后支持多参数的隐式类型转换
//	dict.insert({ "string", "字符串" });
//
//	map<string, string>::iterator it = dict.begin();
//	while (it != dict.end())
//	{
//		cout << (*it).first << ":" << it->second << endl;
//		++it;
//	}
//
//	return 0;
//}


//int main()
//{
//	std::map<char, int> mymap;
//
//	mymap['a'] = 10;
//	mymap['b'] = 20;
//	mymap['c'] = 30;
//
//	std::pair<std::map<char, int>::iterator, std::map<char, int>::iterator> ret;
//	ret = mymap.equal_range('b');
//
//	std::cout << "lower bound points to: ";
//	std::cout << ret.first->first << " => " << ret.first->second << '\n';
//
//	std::cout << "upper bound points to: ";
//	std::cout << ret.second->first << " => " << ret.second->second << '\n';
//
//	return 0;
//}

//int main()
//{
//    std::multimap<char, int> mymm;
//
//    mymm.insert(std::pair<char, int>('a', 10));
//    mymm.insert(std::pair<char, int>('b', 20));
//    mymm.insert(std::pair<char, int>('b', 30));
//    mymm.insert(std::pair<char, int>('b', 40));
//    mymm.insert(std::pair<char, int>('c', 50));
//    mymm.insert(std::pair<char, int>('c', 60));
//    mymm.insert(std::pair<char, int>('d', 60));
//
//    std::cout << "mymm contains:\n";
//    for (char ch = 'a'; ch <= 'd'; ch++)
//    {
//        std::pair <std::multimap<char, int>::iterator, std::multimap<char, int>::iterator> ret;
//        ret = mymm.equal_range(ch);
//        std::cout << ch << " =>";
//        for (std::multimap<char, int>::iterator it = ret.first; it != ret.second; ++it)
//            std::cout << ' ' << it->second;
//        std::cout << '\n';
//    }
//
//    return 0;
//}


//int main()
//{
//	// 利⽤find和iterator修改功能，统计⽔果出现的次数
//	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",\
//	"苹果", "香蕉", "苹果", "香蕉" };
//	map<string, int> countMap;
//	for (const auto& str : arr)
//	{
//		// 先查找⽔果在不在map中
//		// 1、不在，说明⽔果第⼀次出现，则插⼊{⽔果, 1}
//		// 2、在，则查找到的节点中⽔果对应的次数++
//		auto ret = countMap.find(str);
//		if (ret == countMap.end())
//		{
//			countMap.insert({ str, 1 });
//		} 
//		else
//		{
//		ret->second++;
//		}
//	} 
//    for (const auto & e : countMap)
//	{
//		cout << e.first << ":" << e.second << endl;
//	} 
//	
//	return 0;
//}

//int main()
//{
//	// 利⽤find和iterator修改功能，统计⽔果出现的次数
//	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",\
//	"苹果", "香蕉", "苹果", "香蕉" };
//	map<string, int> countMap;
//	for (const auto& str : arr)
//	{
//		countMap[str]++;
//	}
//	for (const auto& e : countMap)
//	{
//		cout << e.first << ":" << e.second << endl;
//	}
//
//	return 0;
//}

//mapped_type& operator[] (const key_type& k);


//mapped_type& operator[] (const key_type& k)
//{
//	pair<iterator, bool> tmp1 = ((*this).insert(make_pair(k, mapped_type()));
//	iterator tmp2 = *(tmp1).first;
//	return tmp2.second;
//}

//(*((this->insert(make_pair(k, mapped_type()))).first)).second；


int main()
{
	map<string, string> dict;
	dict.insert(make_pair("sort", "排序"));

	// key不存在->插⼊ {"insert", string()}
	dict["insert"];

	// 插⼊+修改
	dict["left"] = "左边";

	// 修改
	dict["left"] = "左边、剩余";

	// key存在->查找
	cout << dict["left"] << endl;
	return 0;
}
